home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / audio / bz / bzscreen.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  5.4 KB  |  233 lines
  1. /*
  2.  * Copyright (C) 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /***************************************************************************
  18.  *
  19.  * @(#) - BZ - Multiplayer tank game - Screen scaling.
  20.  *
  21.  * $Id: bzscreen.c,v 1.6 1993/08/11 19:46:18 adele Exp $
  22.  *
  23.  *                    Chris Fouts - Silicon Graphics, Inc.
  24.  *                    October, 1991
  25.  **************************************************************************/
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <X11/Intrinsic.h>
  29. #include <X11/StringDefs.h>
  30. #include <Xm/Xm.h>
  31. #include <X11/Xirisw/GlxMDraw.h>
  32. #include <gl/gl.h>
  33. #include <invent.h>
  34. #include "bz.h"
  35. #define    BZSCREEN_INTERNAL
  36. #include "bzscreen.h"
  37.  
  38. /* BEGIN PROTOTYPES -S bzscreen.c */
  39. static void check_graphics_hw( void ) ;
  40. /* END PROTOTYPES -S bzscreen.c */
  41.  
  42. static char    *version_id = "$Id: bzscreen.c,v 1.6 1993/08/11 19:46:18 adele Exp $" ;
  43.  
  44. DECLARE( MVIEW ) ;
  45. DECLARE( RADAR ) ;
  46. DECLARE( HEAD ) ;
  47. DECLARE( LOADM ) ;
  48. DECLARE( READY ) ;
  49. DECLARE( SCORE ) ;
  50. DECLARE( LIVES ) ;
  51. DECLARE( LEVEL ) ;
  52. DECLARE( NOPLY ) ;
  53. DECLARE( RIGHT ) ;
  54. DECLARE( LEFTT ) ;
  55. DECLARE( MESGS ) ;
  56. DECLARE( OUTMS ) ;
  57. DECLARE( GROND ) ;
  58. DECLARE( LOGOD ) ;
  59. DECLARE( MINES ) ;
  60. DECLARE( FLAGS ) ;
  61.  
  62. extern long        screen_w ;
  63. extern long        screen_h ;
  64. extern Boolean    db_base ;
  65. extern Boolean    mv_RGB ;
  66. extern Boolean    transparentExplosion ;
  67. extern Boolean    use_textures ;
  68.  
  69.  
  70. float    digit_sx ;
  71. float    digit_sy ;
  72.  
  73. void get_screen_dimensions( void )
  74. {
  75.     check_graphics_hw() ;
  76.  
  77.     screen_w = getgdesc( GD_XPMAX ) ;
  78.     screen_h = getgdesc( GD_YPMAX ) ;
  79. #if defined(DEBUG)
  80.     if( getenv( "BZ_SMALL_SCREEN" ) ) {
  81.         screen_w = 1024 ;
  82.         screen_h = 768 ;
  83.         }
  84. #endif /* defined(DEBUG) */
  85.  
  86. #if defined(INDIGO) || defined(SMALL_SCREEN)
  87.     screen_w = 1024 ;
  88.     screen_h = 768 ;
  89. #endif /* defined(INDIGO) || defined(SMALL_SCREEN) */
  90.  
  91.     /*
  92.      * Determine whether or not to use a single buffer base.
  93.      */
  94.     if( getgdesc( GD_BITS_NORM_DBL_CMODE ) < 8 ) {
  95.         db_base = FALSE ;
  96.         /*
  97.          * Determine whether or not to use a single buffer base.
  98.          */
  99.         if( getgdesc( GD_BITS_NORM_SNG_CMODE ) < 8 ) {
  100.             fprintf( stderr, "\n\nSorry, not enough bitplanes.  You need to be"
  101.                      " able to run either\ndouble-buffered RGB mode or"
  102.                      " double-buffered colormap mode with\nat least 4 bits"
  103.                      " per buffer\n\n" ) ;
  104.             end_program( 1 ) ;
  105.             }
  106.         }
  107.     else {
  108.         db_base = TRUE ;
  109.         }
  110.  
  111.     /*
  112.      * Determine whether or not to use RGB mode in the main view.
  113.      */
  114.     if( getgdesc( GD_BITS_NORM_DBL_RED ) < 1 ) {
  115.         mv_RGB = FALSE ;
  116.         transparentExplosion = FALSE ;
  117.         use_textures = FALSE ;
  118.         }
  119.     else {
  120.         mv_RGB = TRUE ;
  121.         }
  122.  
  123. #if defined(INDIGO)
  124.     db_base = FALSE ;
  125.     transparentExplosion = FALSE ;
  126. #endif /* defined(INDIGO) */
  127. }
  128.  
  129.  
  130. void set_up_screen_dimensions( void )
  131. {
  132.     float    w ;
  133.     float    h ;
  134.     float    x_off = 0.f ;
  135.  
  136.     w = (float)screen_w - 1.f ;
  137.     if( 4 * screen_h == 3 * screen_w ) {
  138.         h = (float)screen_h - 1.f ;
  139.         }
  140.     else {
  141.         h = 0.75f * (float)screen_w - 1.f ;
  142.         }
  143.  
  144.     SETUP( MVIEW ) ;
  145.     VPMVIEW_L = FRAMEW ;
  146.     VPMVIEW_R = screen_w - FRAMEW ;
  147.     VPMVIEW_T = screen_h - FRAMEW ;
  148.     FSETUP( MVIEW ) ;
  149.     SETUP( RADAR ) ;
  150.     SETUP( HEAD ) ;
  151.     SETUP( LOADM ) ;
  152.     SETUP( READY ) ;
  153.     SETUP( SCORE ) ;
  154.     SETUP( LIVES ) ;
  155.     SETUP( LEVEL ) ;
  156.     SETUP( NOPLY ) ;
  157.     SETUP( RIGHT ) ;
  158.     SETUP( LEFTT ) ;
  159.     SETUP( MESGS ) ;
  160.     SETUP( OUTMS ) ;
  161.     SETUP( GROND ) ;
  162.     SETUP( LOGOD ) ;
  163.     SETUP( MINES ) ;
  164.     SETUP( FLAGS ) ;
  165.     VPLOGOD_L = VPLOGOD_R - ( VPLOGOD_T - VPLOGOD_B ) ;
  166.     VPGROND_L = VPMVIEW_L ;
  167.     VPGROND_R = VPMVIEW_R ;
  168.     VPGROND_T = ( VPMVIEW_B + VPMVIEW_T ) / 2 ;
  169.     FSETUP( GROND ) ;
  170.  
  171.     digit_sx = w / 1023.f ;
  172.     digit_sy = h / 767.f ;
  173. }
  174.  
  175.  
  176.  
  177. static void check_graphics_hw( void )
  178. {
  179.     inventory_t        *base ;
  180.     inventory_t        *inv ;
  181.  
  182.     /*
  183.      * I do this because there is no way to determine via getgdesc if there
  184.      * is texture mapping is done in hardware or software.  I don't want it
  185.      * on if the texture mapping is done in software for obvious reasons.
  186.      * It does require me to update this file when new hardware comes out,
  187.      * though.  However, the game runs just as well without texturing, so
  188.      * it's no big deal if it's not there.
  189.      */
  190.     inv = base = getinvent() ;
  191.     while( inv != NULL ) {
  192. #if defined( SVR3 )
  193.         switch( inv->class ) {
  194.             case INV_GRAPHICS :
  195.                 switch( inv->type ) {
  196. #else
  197.         switch( inv->inv_class ) {
  198.             case INV_GRAPHICS :
  199.                 switch( inv->inv_type ) {
  200. #endif /* defined( SVR3 ) */
  201.                     case INV_VGX :
  202.                     case INV_VGXT :
  203.                     case INV_RE :
  204. #ifdef INV_VTX
  205.                     case INV_VTX :
  206. #endif /* INV_VTX */
  207.                         use_textures = TRUE ;
  208.                         transparentExplosion = TRUE ;
  209.                         break ;
  210.                     case INV_GR2 :        /* Express graphics */
  211.                         use_textures = FALSE ;
  212.                         transparentExplosion = TRUE ;
  213.                         break ;
  214.                     default :
  215.                         use_textures = FALSE ;
  216.                         transparentExplosion = FALSE ;
  217.                         break ;
  218.                     }
  219.                 break ;
  220.  
  221.             default :
  222.                 break ;
  223.             }
  224.         inv = getinvent() ;
  225.         }
  226.     
  227.     if( base )
  228.         endinvent() ;
  229.  
  230.     return ;
  231. }
  232.  
  233.